// 引入配置文件 - 如果config.js不存在，需要先创建
// import { config } from '../config.js'

/**
 * HTTP请求封装类
 * 提供统一的网络请求处理、错误处理、登录状态管理
 */
class HTTP {
  constructor() {
    // 请求配置
    this.config = {
      // 如果没有config.js，可以在这里直接配置
      apiBaseUrl: 'https://client-hoteltool.shengxuankj.com/api/', // API基础域名
      timeout: 10000,
      header: {
        'Content-Type': 'application/json'
      }
    }
    
    // 状态码定义
    this.statusCode = {
      SUCCESS: [0, 2], // 成功状态码
      LOGIN_EXPIRED: [1, 4], // 登录失效状态码
      ERROR: 'other' // 其他错误
    }
  }

  /**
   * 发起网络请求
   * @param {Object} options 请求配置
   * @param {string} options.url 请求路径
   * @param {Object} options.data 请求参数
   * @param {string} options.method 请求方法
   * @param {Object} options.header 请求头
   * @param {boolean} options.showLoading 是否显示加载提示
   * @param {boolean} options.showError 是否显示错误提示
   * @returns {Promise}
   */
  request({
    url,
    data = {},
    method = 'GET',
    header = {},
    showLoading = false,
    showError = true
  }) {
    return new Promise((resolve, reject) => {
      // 显示加载提示
      if (showLoading) {
        wx.showLoading({
          title: '加载中...',
          mask: true
        })
      }

      // 处理请求参数
      const requestData = this._processRequestData(data)
      
      // 构建请求头
      const requestHeader = this._buildHeader(header)
      
      // 构建完整的URL
      const fullUrl = this._buildUrl(url)

      console.log(`[HTTP Request] ${method} ${fullUrl}`, requestData)

      wx.request({
        url: fullUrl,
        method: method.toUpperCase(),
        data: requestData,
        header: requestHeader,
        timeout: this.config.timeout,
        success: (res) => {
          this._handleSuccess(res, resolve, reject, showError)
        },
        fail: (err) => {
          this._handleFail(err, reject, showError)
        },
        complete: () => {
          // 隐藏加载提示
          if (showLoading) {
            wx.hideLoading()
          }
        }
      })
    })
  }

  /**
   * 处理请求参数
   * @param {Object} data 原始数据
   * @returns {Object} 处理后的数据
   */
  _processRequestData(data) {
    if (!data || Object.keys(data).length === 0) {
      return {}
    }

    // 深拷贝数据，避免修改原始对象
    const processedData = JSON.parse(JSON.stringify(data))
    
    // 添加时间戳（用于防缓存或签名）
    processedData.timestamp = Date.now()
    
    return processedData
  }

  /**
   * 构建请求头
   * @param {Object} customHeader 自定义请求头
   * @returns {Object} 完整的请求头
   */
  _buildHeader(customHeader = {}) {
    // 获取token
    const app = getApp()
    const token = app?.globalData?.token || wx.getStorageSync('token') || ''
    
    return {
      ...this.config.header,
      token,
      ...customHeader
    }
  }

  /**
   * 构建完整URL
   * @param {string} url 请求路径
   * @returns {string} 完整URL
   */
  _buildUrl(url) {
    // 如果是完整URL，直接返回
    if (url.startsWith('http://') || url.startsWith('https://')) {
      return url
    }
    
    // 移除开头的斜杠，避免重复
    const cleanUrl = url.startsWith('/') ? url.slice(1) : url
    
    return `${this.config.apiBaseUrl}${cleanUrl}`
  }

  /**
   * 处理请求成功回调
   * @param {Object} res 响应对象
   * @param {Function} resolve Promise resolve
   * @param {Function} reject Promise reject
   * @param {boolean} showError 是否显示错误提示
   */
  _handleSuccess(res, resolve, reject, showError) {
    console.log('[HTTP Response]', res)

    // 检查响应结构
    if (!res.data || typeof res.data !== 'object') {
      const error = new Error('响应数据格式错误')
      this._handleError(error, reject, showError)
      return
    }

    const { code, msg, data } = res.data
    
    // 成功状态
    if (this.statusCode.SUCCESS.includes(code)) {
      resolve(res.data)
      return
    }
    
    // 登录失效
    if (this.statusCode.LOGIN_EXPIRED.includes(code)) {
      this._handleLoginExpired(msg)
      reject(new Error(msg || '登录失效'))
      return
    }
    
    // 其他错误
    const error = new Error(msg || '请求失败')
    error.code = code
    this._handleError(error, reject, showError)
  }

  /**
   * 处理请求失败回调
   * @param {Object} err 错误对象
   * @param {Function} reject Promise reject
   * @param {boolean} showError 是否显示错误提示
   */
  _handleFail(err, reject, showError) {
    console.error('[HTTP Error]', err)
    
    let errorMessage = '网络请求失败'
    
    // 根据错误类型提供更友好的提示
    if (err.errMsg) {
      if (err.errMsg.includes('timeout')) {
        errorMessage = '请求超时，请检查网络连接'
      } else if (err.errMsg.includes('fail')) {
        errorMessage = '网络连接失败，请检查网络'
      }
    }
    
    const error = new Error(errorMessage)
    this._handleError(error, reject, showError)
  }

  /**
   * 处理登录失效
   * @param {string} message 错误消息
   */
  _handleLoginExpired(message) {
    const loginMessages = ['登录失效', '当前登录已失效', '请重新登录']
    const isLoginExpired = loginMessages.some(msg => 
      message && message.includes(msg)
    )
    
    if (!isLoginExpired) {
      return
    }

    // 显示提示
    wx.showToast({
      title: message || '登录失效，请重新登录',
      icon: 'none',
      duration: 2000
    })

    // 清除本地存储
    this._clearUserData()

    // 延迟跳转到登录页
    setTimeout(() => {
      wx.redirectTo({
        url: '/pages/login/login'
      }).catch(() => {
        // 如果登录页不存在，跳转到首页
        wx.switchTab({
          url: '/pages/index/index'
        })
      })
    }, 1500)
  }

  /**
   * 清除用户数据
   */
  _clearUserData() {
    const keys = ['token', 'userinfo', 'userInfo']
    
    keys.forEach(key => {
      wx.removeStorageSync(key)
    })
    
    // 清除全局数据
    const app = getApp()
    if (app && app.globalData) {
      app.globalData.token = ''
      app.globalData.userInfo = null
    }
  }

  /**
   * 处理错误
   * @param {Error} error 错误对象
   * @param {Function} reject Promise reject
   * @param {boolean} showError 是否显示错误提示
   */
  _handleError(error, reject, showError) {
    if (showError) {
      wx.showToast({
        title: error.message || '请求失败',
        icon: 'none',
        duration: 2000
      })
    }
    
    reject(error)
  }

  /**
   * GET请求快捷方法
   */
  get(url, data, options = {}) {
    return this.request({
      url,
      data,
      method: 'GET',
      ...options
    })
  }

  /**
   * POST请求快捷方法
   */
  post(url, data, options = {}) {
    return this.request({
      url,
      data,
      method: 'POST',
      ...options
    })
  }

  /**
   * PUT请求快捷方法
   */
  put(url, data, options = {}) {
    return this.request({
      url,
      data,
      method: 'PUT',
      ...options
    })
  }

  /**
   * DELETE请求快捷方法
   */
  delete(url, data, options = {}) {
    return this.request({
      url,
      data,
      method: 'DELETE',
      ...options
    })
  }
}

// 创建单例
const http = new HTTP()

export { http, HTTP }